package com.hugoo.core.db.mo;

import java.util.ArrayList;
import java.util.ListIterator;

/**
 *
 * @author Xinton
 */
public class RecordSet<T> extends ArrayList<T> {

    // 记录集信息
    /**
     * 总页数
     */
    public int tp = -1;
    /**
     * 当前页号
     */
    public int cp = -1;
    /**
     * 每页最大记录数
     */
    public int ps = -1;
    /**
     * 总记录数
     */
    public int tt = 0;
    /**
     * 当前指向的记录位置 ( 初始位置在第一条记录之前的空位上 )
     */
    private int cr = 0;

    /**
     * 取得当前记录的位置
     *
     * @return 记录的位置
     */
    public int getRow() {
        return cr;
    }

    @Override
    public String toString() {
        ListIterator e = listIterator();
        if (e == null) {
            return "[]";
        }
        StringBuilder sb = new StringBuilder();
        sb.append('[');
        while (e.hasNext()) {
            sb.append(e.next()).append(',');
        }
        if (sb.length() > 2) {
            sb.replace(sb.length() - 1, sb.length(), "]");
        } else {
            sb.append(']');
        }
        return sb.toString();
    }

    public String toComboxString(String px) {
        
        ListIterator e = listIterator();
        if (e == null) {
            return "[]";
        }
        StringBuilder sb = new StringBuilder();
        sb.append('[');
        while (e.hasNext()) {
            sb.append(e.next()).append(',');
        }
        if ("FST".equals(px)) {
            sb.replace(1, 2, "{\"selected\":true,");
        } else if ("LST".equals(px)) {
            sb.replace(sb.length() - 2, sb.length()-1, ",\"selected\":true}");
        }
        if (sb.length() > 2) {
            sb.replace(sb.length() - 1, sb.length(), "]");
        } else {
            sb.append(']');
        }
        return sb.toString();
    }

    public String toJson() {
        ListIterator e = listIterator();
        if (e == null) {
            return "{\"total\":0,\"rows\":[]}";
        }
        StringBuilder sb = new StringBuilder();
        tt = tt == 0 ? this.size() : tt;
        sb.append("{\"total\":").append(tt).append(",\"rows\":[");
        while (e.hasNext()) {
            sb.append(e.next()).append(',');
        }
        if (tt > 0) {
            sb.replace(sb.length() - 1, sb.length(), "]}");
        } else {
            sb.append("]}");
        }
        return sb.toString();
    }

    /**
     * 得到第n条记录
     *
     * @param i 记录位置 ( 取值范围: 1--返回的记录数 )
     * @return 成功返回记录, 异常或失败返回 false
     */
    public Record getRecord(int i) {
        try {
            return (Record) this.get(i - 1);
        } catch (Exception e) {
            //Log.error(e);
            return null;
        }
    }

    /**
     * 得到当前记录
     *
     * @return 成功返回记录, 异常或失败返回 false
     */
    public Record getRecord() {
        if (isBeforeFirst()) {
            //Log.warn("指针在初始位置, 请使用 first() 或 next() 方法将指针指向第一条记录");
            return null;
        }
        if (isAfterLast()) {
            //Log.warn("指针在结束位置, 请使用 first() 方法将指针指向第一条记录");
            return null;
        }
        return getRecord(cr);
    }

    /**
     * 定位到绝对位置的记录
     *
     * @param row 记录位置 ( 0--返回的记录数+1 )
     * @return 成功返回 true, 异常或失败返回 false
     */
    public boolean absolute(int row) {
        if (0 <= row && row <= this.size() + 1) {
            cr = row;
            return true;
        } else {
            return false;
        }
    }

    /**
     * 定位到首条记录之前
     */
    public void beforeFirst() {
        cr = 0;
    }

    /**
     * 定位到末条记录之后
     */
    public void afterLast() {
        cr = this.size() + 1;
    }

    /**
     * 定位到首条记录
     *
     * @return 成功返回 true, 失败返回 false
     */
    public boolean first() {
        if (this.isEmpty()) {
            return false;
        } else {
            cr = 1;
            return true;
        }
    }

    /**
     * 定位到末条记录
     *
     * @return 成功返回 true, 失败返回 false
     */
    public boolean last() {
        if (this.isEmpty()) {
            return false;
        } else {
            cr = this.size();
            return true;
        }
    }

    /**
     * 是否在首条记录之前
     *
     * @return 是返回 true, 否返回 false
     */
    public boolean isBeforeFirst() {
        if (cr == 0) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 是否在末条记录之后
     *
     * @return 是返回 true, 否返回 false
     */
    public boolean isAfterLast() {
        if (cr == this.size() + 1) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 是否位于首条记录
     *
     * @return 是返回 true, 否返回 false
     */
    public boolean isFirst() {
        if (this.isEmpty()) {
            return false;
        } else {
            if (cr == 1) {
                return true;
            } else {
                return false;
            }
        }
    }

    /**
     * 是否位于末条记录
     *
     * @return 是返回 true, 否返回 false
     */
    public boolean isLast() {
        if (this.isEmpty()) {
            return false;
        } else {
            if (cr == this.size()) {
                return true;
            } else {
                return false;
            }
        }
    }

    /**
     * 是否位于首页
     *
     * @return 是返回 true, 否返回 false
     */
    public boolean isFirstPage() {
        if (this.isEmpty()) {
            return true;
        } else {
            if (this.cp == 1) {
                return true;
            } else {
                return false;
            }
        }
    }

    /**
     * 是否位于末页
     *
     * @return 是返回 true, 否返回 false
     */
    public boolean isLastPage() {
        if (this.isEmpty()) {
            return true;
        } else {
            if (this.cp == this.tp) {
                return true;
            } else {
                return false;
            }
        }
    }

    /**
     * 定位到前一条记录
     *
     * @return 成功返回 true, 失败返回 false
     */
    public boolean previous() {
        if (cr < 1) {
            return false;
        } else {
            cr--;
            if (cr < 1) {
                return false;
            } else {
                return true;
            }
        }
    }

    /**
     * 定位到后一条记录
     *
     * @return 成功返回 true, 失败返回 false
     */
    public boolean next() {
        if (cr > this.size()) {
            return false;
        } else {
            cr++;
            if (cr > this.size()) {
                return false;
            } else {
                return true;
            }
        }
    }

    /**
     * 得到数字(推荐使用这个方法得到数字, 可以避免各种数据库数据类型不同而产生的问题)
     *
     * @param key 字段名
     * @return 数字
     */
    public double getNumber(String key) {
        return Double.parseDouble(getString(key));
    }

    /**
     * 得到 String 类型的值(用 getObject 方法取得, 并使用了 trim 方法去掉两端空格, 当对象为空时返回空字符串)
     *
     * @param key 字段名
     * @return String 类型的值
     */
    public String getString(String key) {
        Record r = this.getRecord();
        if (r == null) {
            return "";
        }
        return r.getString(key);
    }

    /**
     * 得到 Timestamp 类型的值
     *
     * @param key 字段名
     * @return Timestamp 类型的值
     */
    public java.sql.Timestamp getTimestamp(String key) {
        return this.getRecord().getTimestamp(key);
    }

    /**
     * 得到 Date 类型的值
     *
     * @param key 字段名
     * @return Date 类型的值
     */
    public java.sql.Date getDate(String key) {
        return this.getRecord().getDate(key);
    }

    public String getDateStr(String key) {
        return this.getRecord().getDateStr(key);
    }

    /**
     * 得到 Time 类型的值
     *
     * @param key 字段名
     * @return Time 类型的值
     */
    public java.sql.Time getTime(String key) {
        return this.getRecord().getTime(key);
    }

    /**
     * 得到 BigDecimal 类型的值
     *
     * @param key 字段名
     * @return BigDecimal 类型的值
     */
    public java.math.BigDecimal getBigDecimal(String key) {
        return this.getRecord().getBigDecimal(key);
    }

    /**
     * 得到 long 类型的值
     *
     * @param key 字段名
     * @return long 类型的值
     */
    public long getLong(String key) {
        return this.getRecord().getLong(key).longValue();
    }

    /**
     * 得到 int 类型的值
     *
     * @param key 字段名
     * @return int 类型的值
     */
    public int getInt(String key) {
        return this.getRecord().getInteger(key).intValue();
    }

    /**
     * 得到 short 类型的值
     *
     * @param key 字段名
     * @return short 类型的值
     */
    public short getShort(String key) {
        return this.getRecord().getShort(key).shortValue();
    }

    /**
     * 得到 double 类型的值
     *
     * @param key 字段名
     * @return double 类型的值
     */
    public double getDouble(String key) {
        return this.getRecord().getDouble(key).doubleValue();
    }

    /**
     * 得到 float 类型的值
     *
     * @param key 字段名
     * @return float 类型的值
     */
    public float getFloat(String key) {
        return this.getRecord().getFloat(key).floatValue();
    }

    /**
     * 得到 boolean 类型的值
     *
     * @param key 字段名
     * @return boolean 类型的值
     */
    public boolean getBoolean(String key) {
        return this.getRecord().getBoolean(key).booleanValue();
    }

    /**
     * 得到 byte 类型的值
     *
     * @param key 字段名
     * @return byte 类型的值
     */
    public byte getByte(String key) {
        return this.getRecord().getByte(key).byteValue();
    }

    /**
     * 得到 byte[] 类型的值
     *
     * @param key 字段名
     * @return byte[] 类型的值
     */
    public byte[] getBytes(String key) {
        return this.getRecord().getBytes(key);
    }

    /**
     * 得到 Blob 类型的值
     *
     * @param key 字段名
     * @return Blob 类型的值
     */
    public java.sql.Blob getBlob(String key) {
        return this.getRecord().getBlob(key);
    }

    /**
     * 得到 Clob 类型的值
     *
     * @param key 字段名
     * @return Clob 类型的值
     */
    public java.sql.Clob getClob(String key) {
        return this.getRecord().getClob(key);
    }

    public String getClobStr(String key) {
        return this.getRecord().getClobStr(key);
    }

    /**
     * 得到 Array 类型的值
     *
     * @param key 字段名
     * @return Array 类型的值
     */
    public java.sql.Array getArray(String key) {
        return this.getRecord().getArray(key);
    }

    /**
     * 得到 InputStream 类型的值
     *
     * @param key 字段名
     * @return InputStream 类型的值
     */
    public java.io.InputStream getBinaryStream(String key) {
        return this.getRecord().getBinaryStream(key);
    }

    /**
     * 得到 Object 类型的值 注意: 如果字段为 char 类型, 要注意返回的值尾部是否有多余的空格
     *
     * @param key 字段名
     * @return Object 类型的值
     */
    public Object getObject(String key) {
        return this.getRecord().getObject(key);
    }

    /**
     * 返回相邻的页号
     *
     * @param size 相邻的页数
     * @return 成功返回所有相邻的页号集合, 失败返回 null
     */
    public int[] getNeighbouringPage(int size) {
        try {
            int left = (this.cp - 1 > size) ? size : this.cp - 1;
            int right = (this.tp - this.cp > size) ? size
                    : this.tp - this.cp;
            int begin = this.cp - left;
            int[] num = new int[left + 1 + right];
            for (int i = 0; i < num.length; i++) {
                num[i] = begin + i;
            }
            return num;
        } catch (Exception e) {
            //Log.error(e);
            return null;
        }
    }

    public int getCommonPageSize() {
        return ps;
    }

    public void setCommonPageSize(int commonPageSize) {
        this.ps = commonPageSize;
    }

    public int getCurrentPage() {
        return cp;
    }

    public void setCurrentPage(int currentPage) {
        this.cp = currentPage;
    }

    public int getCurrentRecordRow() {
        return cr;
    }

    public void setCurrentRecordRow(int currentRecordRow) {
        this.cr = currentRecordRow;
    }

    public int getTotalPage() {
        return tp;
    }

    public void setTotalPage(int totalPage) {
        this.tp = totalPage;
    }

    public int getTotalRecodeCount() {
        return tt;
    }

    public void setTotalRecodeCount(int totalRecodeCount) {
        this.tt = totalRecodeCount;
    }
}
